
# Messaging 

## 📘 Resources
- [clemensv/messaging](https://github.com/clemensv/messaging) - Resource collection for messaging and eventing
- [Messaging Playlist - CodeOpinion](https://www.youtube.com/playlist?list=PLThyvG1mlMzm2FyVpKDiU2c7VtrB2Zezg)
- [DDD and Messaging Architectures](https://verraes.net/2019/05/ddd-msg-arch/)
- [Martin Kleppmann Yotube](https://www.youtube.com/channel/UClB4KPy5LkJj1t3SgYVtMOQ/videos)
- [Sairyss/distributed-systems-topics](https://github.com/Sairyss/distributed-systems-topics) - Topics and resources related to distributed systems, system design, microservices, scalability and performance, etc
- [donnemartin/system-design-primer](https://github.com/donnemartin/system-design-primer) - Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.

## 📕 Articles
- [Messaging patterns](https://docs.microsoft.com/en-us/azure/architecture/patterns/category/messaging) 
- [Communication in a microservice architecture](https://docs.microsoft.com/en-us/dotnet/architecture/microservices/architect-microservice-container-applications/communication-in-microservice-architecture)
- [Asynchronous message-based communication](https://docs.microsoft.com/en-us/dotnet/architecture/microservices/architect-microservice-container-applications/asynchronous-message-based-communication) 
- [Modular Monolith: Integration Styles](http://www.kamilgrzybek.com/tag/messaging/) 
- [Marrying RESTful HTTP with Asynchronous and Event-Driven Services](https://sookocheff.com/post/api/marrying-restful-http-with-asynchronous-design/)
- [DDD and Messaging Architectures](https://verraes.net/2019/05/ddd-msg-arch/) 
- [Asynchronous Messaging Patterns](https://blogs.mulesoft.com/api-integration/patterns/asynchronous-messaging-patterns/)
- [Messaging Patterns Overview](https://www.enterpriseintegrationpatterns.com/patterns/messaging/)
- [Service Activator](https://www.enterpriseintegrationpatterns.com/patterns/messaging/MessagingAdapter.html)
- [Message Properties](https://codeopinion.com/message-properties/)
- [Message Naming Guidelines](https://codeopinion.com/message-naming-guidelines/)
- [Organizing (Commands, Events & Handlers) in Microservices](https://codeopinion.com/organizing-commands-events-handlers-in-microservices/)
- [REST APIs for Microservices? Beware!](https://codeopinion.com/rest-apis-for-microservices-beware/)
- [Messaging Commands & Events Explained!](https://codeopinion.com/messaging-commands-events-explained/)
- [Event Choreography & Orchestration (Sagas)](https://codeopinion.com/event-choreography-orchestration-sagas/)
- [Outbox Pattern: Reliably Save State & Publish Events](https://codeopinion.com/outbox-pattern-reliably-save-state-publish-events/)
- [Handling Duplicate Messages (Idempotent Consumers)](https://codeopinion.com/handling-duplicate-messages-idempotent-consumers/)
- [Message-IDs for Handling Concurrency](https://codeopinion.com/message-ids-for-handling-concurrency/)
- [CAP: Event Bus & Outbox Pattern](https://codeopinion.com/cap-event-bus-outbox-pattern/)
- [Message Queue Overload from High Processing Latency](https://codeopinion.com/message-queue-overload-from-high-processing-latency/)
- [Processing commands with Hangfire and MediatR](http://www.kamilgrzybek.com/design/processing-commands-with-hangfire-and-mediatr/)
- [Using Hangfire and MediatR as a Message Dispatcher](https://codeopinion.com/using-hangfire-and-mediatr-as-a-message-dispatcher/)
- [Idempotent Aggregates](https://codeopinion.com/idempotent-aggregates/)
- [Identify Commands & Events](https://codeopinion.com/identify-commands-events/)
- [Idempotent Commands](https://codeopinion.com/idempotent-commands/)
- [Moving work Out-of-Process using Brighter and RabbitMQ](https://codeopinion.com/moving-work-out-of-process-using-brighter-and-rabbitmq/)
- [Thin vs Fat Integration Events](https://codeopinion.com/thin-vs-fat-integration-events/)
- [Events: Fat or Thin](https://codesimple.blog/2019/02/16/events-fat-or-thin/)
- [Events on the Outside vs Events on the Inside](https://codesimple.blog/2021/03/14/events-on-the-outside-vs-events-on-the-inside/)
- [Patterns for Decoupling in Distributed Systems: Fat Event](https://verraes.net/2019/05/patterns-for-decoupling-distsys-fat-event/)
- [Message Sender: Who Sent the Command/Event?](https://codeopinion.com/message-sender-who-sent-the-command-event/)
- [Why use DTOs (Data Transfer Objects)?](https://codeopinion.com/why-use-dtos-data-transfer-objects/)
- [Event Versioning Guidelines](https://codeopinion.com/event-versioning-guidelines/)
- [Fat vs thin domain events](https://adrian-philipp.com/notes/fat-vs-thin-domain-events)
- [Putting your events on a diet](https://particular.net/blog/putting-your-events-on-a-diet)
- [What do you mean by “Event-Driven”?](https://martinfowler.com/articles/201701-event-driven.html)
- [Are CQRS commands part of the domain model?](https://enterprisecraftsmanship.com/posts/cqrs-commands-part-domain-model/)
- [DTO vs Value Object vs POCO](https://enterprisecraftsmanship.com/posts/dto-vs-value-object-vs-poco/)
- [Event Based Architecture: What do you mean by EVENT?](https://codeopinion.com/event-based-architecture-what-do-you-mean-by-event/)
- [What's the difference between a command and an event?](https://www.eventstore.com/blog/whats-the-difference-between-a-command-and-an-event)
- [Outbox, Inbox patterns and delivery guarantees explained](https://event-driven.io/en/outbox_inbox_patterns_and_delivery_guarantees_explained/)
- [Distributed State — Challenges and Options](https://medium.com/swlh/distributed-state-management-80c8100bb563)
- [Message Naming Conventions](https://jimmybogard.com/message-naming-conventions/)
- [Building an Event Driven .NET Application: The Fundamentals](https://wrapt.dev/blog/building-an-event-driven-dotnet-application-the-fundamentals)
- [Building an Event Driven .NET Application: Setting Up MassTransit and RabbitMQ](https://wrapt.dev/blog/building-an-event-driven-dotnet-application-setting-up-masstransit-and-rabbitmq)
- [Kafka vs RabbitMQ vs AWS SNS/SQS: Which Broker to Choose?](https://www.aspecto.io/blog/kafka-vs-rabbitmq-vs-aws-sns-sqs-which-broker-to-choose/)
- [Event Pitfalls (and How to Avoid Them)](https://dev.to/peholmst/event-pitfalls-and-how-to-avoid-them-4d31)
- [Designing Domain Events](https://medium.com/casaone-engineering/designing-domain-events-5efc6e25da52)
- [Competing Consumers Pattern for Scalability](https://codeopinion.com/competing-consumers-pattern-for-scalability/)
- [Patterns for Decoupling in Distributed Systems: Explicit Public Events](http://verraes.net/2019/05/patterns-for-decoupling-distsys-explicit-public-events/)
- [Event immutability and dealing with change](https://www.eventstore.com/blog/event-immutability-and-dealing-with-change)
- [Transient fault handling](https://docs.microsoft.com/en-us/azure/architecture/best-practices/transient-faults)
- [SHARING DATA BETWEEN MODULES IN MODULAR MONOLITH](https://dev.to/lukaszreszke/sharing-data-between-modules-in-modular-monolith-50on)
- [Comparing Techniques for Communicating Between Services](https://ardalis.com/comparing-techniques-communicating-between-services/)
- [Bus or Queue](https://ardalis.com/bus-or-queue/?utm_sq=gn4zxe3o0t)
- [Improving Monolith's Availability](https://www.ledjonbehluli.com/posts/improving_monoliths_availability/)
- [The Outbox Pattern in Event-Driven ASP.NET Core Microservice Architectures](https://itnext.io/the-outbox-pattern-in-event-driven-asp-net-core-microservice-architectures-10b8d9923885)
- [Competing Consumers](https://www.enterpriseintegrationpatterns.com/patterns/messaging/CompetingConsumers.html)
- [Competing Consumers pattern](https://docs.microsoft.com/en-us/azure/architecture/patterns/competing-consumers)
- [REST vs Messaging for Microservices – Which One is Best?](https://solace.com/blog/experience-awesomeness-event-driven-microservices/)
- [RPC vs. Messaging – which is faster?](https://particular.net/blog/rpc-vs-messaging-which-is-faster)
- [Microservices patterns: synchronous vs asynchronous communication](https://greeeg.com/issues/microservices-patterns-synchronous-vs-asynchronous)
- [Async request processing](https://rafaelldi.blog/posts/async-request-processing/)
- [Event Feeds: Simple and reliable messaging infrastructure](https://www.erikheemskerk.nl/event-feeds/)
- [What's the difference between a command and an event?](https://event-driven.io/en/whats_the_difference_between_event_and_command/)
- [Events should be as small as possible, right?](https://event-driven.io/en/events_should_be_as_small_as_possible/)
- [How to build a simple event pipeline](https://event-driven.io/en/how_to_build_simple_event_pipeline/)
- [Wire Tap Enterprise Integration Pattern](https://www.baeldung.com/wiretap-pattern)
- [Wire Tap](https://www.enterpriseintegrationpatterns.com/WireTap.html)
- [Message Ordering in Pub/Sub or Queues](https://codeopinion.com/message-ordering-in-pub-sub-or-queues/)
- [Mapping event type by convention](https://event-driven.io/en/how_to_map_event_type_by_convention/)
- [Distributed systems evolution: message contracts](https://milestone.topics.it/2022/07/04/messages-evolution.html)
- [Back to Basics: commands, events, and messages](https://milestone.topics.it/2023/05/25/back-to-basics-messages.html)
- [Define messages as POCO, interfaces, or records. Does it really matter?](https://milestone.topics.it/2023/10/31/defining-messages.html)
- [Internal and external events, or how to design event-driven API](https://event-driven.io/en/internal_external_events/)
- [9 PROCESSING PATTERNS](https://www.messagehandler.net/patterns/)

## 📺 Videos

- [Handling Concurrency with Message-IDs | Event Driven Architecture](https://www.youtube.com/watch?v=wefvl2ohiQc)
- [Message Naming Guidelines | Event Driven Architecture](https://www.youtube.com/watch?v=EmtOB2XexJI)
- [Event Versioning Guidelines](https://www.youtube.com/watch?v=L8eH1XaRnPw&list=PLThyvG1mlMzm2FyVpKDiU2c7VtrB2Zezg)
- [Organizing (Commands, Events & Handlers) in Microservices/SOA](https://www.youtube.com/watch?v=8j5ETvSSNpc)
- [Service Oriented Architecture: Commands & Events Explained!](https://www.youtube.com/watch?v=oJiUjiWeesQ)
- [Handling Duplicate Messages (Idempotent Consumers)](https://www.youtube.com/watch?v=xeBY8fCWfvU)
- [Sagas: Event Choreography & Orchestration (NServiceBus)](https://www.youtube.com/watch?v=rO9BXsl4AMQ)
- [CAP: Event Bus & Outbox Pattern](https://www.youtube.com/watch?v=dnhPzILvgeo&t=50s)
- [Thin or Fat Events? Are your boundaries right?](https://www.youtube.com/watch?v=vDtK-ccQWkw)
- [GOTO 2017 • The Many Meanings of Event-Driven Architecture • Martin Fowler](https://www.youtube.com/watch?v=STKCRSUsyP0)
- [On .NET Live - Messaging Patterns for .NET Developers](https://www.youtube.com/watch?v=ef1DK76rseM)
- [Competing Consumers Pattern for Scalability | Message Queues](https://www.youtube.com/watch?v=xv6Ljbq6me8)
- [Event Driven Architecture for Real-Time Web](https://www.youtube.com/watch?v=Tu1GEIhkIqU)
- [Learnings from Running 1000s of Production RabbitMQ Clusters • Lovisa Johansson • RabbitMQ Summit](https://www.youtube.com/watch?v=nxQrpLfX3rs)
- [What is Event Driven Architecture? (EDA - part 1)](https://www.youtube.com/watch?v=DQ5Cbt8DQbM)
- [The Saga Pattern in Microservices (EDA - part 2)](https://www.youtube.com/watch?v=C0rGwyJkDTU)
- [GOTO 2019 • Temporal Modelling • Mathias Verraes](https://www.youtube.com/watch?v=KNqOWT0lOYY)
- [Handling Failures in Message Driven Architecture](https://www.youtube.com/watch?v=SesEYHGhlLQ)
- [Building a Mediator library in .NET from scratch](https://www.youtube.com/watch?v=4e83trumwcM)
- [Message Driven Architecture to DECOUPLE a Monolith](https://www.youtube.com/watch?v=bxGkavGaEiM)
- [Synchronous vs Messaging: When to use which?](https://www.youtube.com/watch?v=LMKVzguhFw4)
- [Moving work Out-of-Process using Brighter and RabbitMQ](https://www.youtube.com/watch?v=kG4WLiZEAuc)
- [Building a Request Pipeline for Separating Concerns with Pipes & Filters](https://www.youtube.com/watch?v=msXtN15qXOE)
- [Distributed Messaging Patterns](https://www.youtube.com/watch?v=ZGloN_GOc9o)
- [RPC vs Messaging: When to use which?](https://www.youtube.com/watch?v=LMKVzguhFw4)
- [Beyond REST and RPC: Asynchronous Eventing and Messaging Patterns](https://www.youtube.com/watch?v=6zs-PhgfLU4)
- [Modern .NET Messaging using MassTransit](https://www.youtube.com/watch?v=jQNQDLv7QmU)
- [Was that message processed? Asynchronous Request-Response Pattern](https://www.youtube.com/watch?v=6UC6btG3wVI)
- [Messaging Building Blocks: Commands & Events](https://www.youtube.com/watch?v=vw11J2BN7lY)
- [Message delivery (at least-once, at most-once, exactly once?) | Messaging in distributed systems](https://www.youtube.com/watch?v=l6nLt4Km1cA)
- [Message Ordering in Pub/Sub or Queue](https://www.youtube.com/watch?v=ILEb5LsSf5w)
- [Avoiding a QUEUE Backlog Disaster with Backpressure & Flow Control](https://www.youtube.com/watch?v=BIGiLJJlE08)
- [Avoiding Batch Jobs by a message in the FUTURE](https://www.youtube.com/watch?v=zWgqj2OEKX8)
- [Wolverine: Your Next Messaging Library](https://www.youtube.com/watch?v=EGwepoGG0CM)
- [Clean Message Bus Consumers with MediatR in .NET](https://www.youtube.com/watch?v=wnqBmv1RJNE)
- [Using Open Telemetry with the MassTransit Test Harness?](https://www.youtube.com/watch?v=7PM9XUAAMtA)
- [MassTransit Message Contract Sharing using NuGet](https://www.youtube.com/watch?v=5i_VQBYvTIQ)
- [Versioning your MassTransit message contracts](https://www.youtube.com/watch?v=PNNxJthctgk)
  
## 📦 Libraries

- [Enexure.MicroBus](https://github.com/Lavinski/Enexure.MicroBus) - MicroBus is a simple in process Mediator for .NET
- [Foundatio](https://github.com/exceptionless/Foundatio) - A common interface with in memory, redis and azure implementations.
- [Kledex](https://github.com/lucabriguglia/Kledex) - .NET Standard framework to create simple and clean design. Advanced features for DDD, CQRS and Event Sourcing.
- [MQTTnet](https://github.com/chkr1011/MQTTnet) - Tnet is a high performance .NET library for MQTT based communication.
- [OpenCQRS](https://github.com/OpenCQRS/OpenCQRS) - .NET Core library for DDD, CQRS and Event Sourcing with Azure Service Bus integration. Supported database providers for the Command and the Event stores are: DocumentDB, MongoDB, SQL Server, MySQL, PostgreSQL and SQLite.
- [Rebus](https://github.com/rebus-org/Rebus) - Simple and lean service bus implementation for .NET.
- [RestBus](https://github.com/tenor/RestBus) - Messaging library for RabbitMq.
- [tossit](https://github.com/turgayozgur/tossit) - Simple, easy to use library for distributed job/worker logic. Distributed messages handled by built in RabbitMQ implementation.
- [Steeltoe](https://github.com/SteeltoeOSS/Steeltoe) - Steeltoe .NET Core Components: CircuitBreaker, Configuration, Connectors, Discovery, Logging, Management, and Security
- [MetroBus](https://github.com/GokGokalp/MetroBus) - Lightweight messaging wrapper of
- [Abp](https://github.com/abpframework/abp/tree/15589f4c1fbd6323cc80a5ce597b1ebf32d9eb07/framework/src/Volo.Abp.EventBus) - Open Source Web Application Framework for ASP.NET Core
- [OpenSleigh](https://github.com/mizrael/OpenSleigh) - OpenSleigh is a Saga management library for .NET Core.
- [knightbus](https://github.com/BookBeat/knightbus) - Fast multi-transport messaging framework
- [SlimMessageBus](https://github.com/zarusz/SlimMessageBus) - Lightweight message bus interface for .NET (pub/sub and request-response) with transport plugins for popular message brokers.
- [silverback](https://github.com/BEagle1984/silverback) - Silverback is a simple but feature-rich framework to build reactive/event-driven applications or microservices with .net core.
- [Obvs](https://github.com/christopherread/Obvs) - An observable microservice bus library for .NET, that wraps the underlying message transports in simple Rx based interfaces.
- [Platibus](https://github.com/sweetlandj/Platibus) - Decentralized asynchronous messaging framework
- [EventBus](https://github.com/jacqueskang/EventBus) - A .NET Core ultra lightweight in-memory event bus implementation.
- [Enbiso.NLib](https://github.com/enbiso/Enbiso.NLib) - .Net Standard Libraries for Microservices
- [eventbus](https://github.com/tinglesoftware/eventbus) - A simple Event Bus abstraction layer for working with events in .NET.
- [AzureFromTheTrenches.Commanding](https://github.com/JamesRandall/AzureFromTheTrenches.Commanding) - A configuration based commanding and mediator framework that supports command dispatch and execution in-process, over HTTP or over Azure Storage Queues. Written to .NET Standard 2.0 and supports many popular runtimes including .NET Core and .NET 4.6.x.
- [Brighter](https://github.com/BrighterCommand/Brighter) - Command Dispatcher, Processor, and Distributed Task Queue
- [Darker](https://github.com/BrighterCommand/Darker) - The query-side counterpart of Brighter
- [MassTransit](https://github.com/MassTransit/MassTransit) - Distributed Application Framework for .NET
- [ViennaNET](https://github.com/Raiffeisen-DGTL/ViennaNET) - Framework for quickly creating enterprise microservices on .NET Core
- [MemBus](https://github.com/flq/MemBus/tree/master/MemBus) - Pure In-Memory Publish/Subscribe .NET Bus
- [Cysharp/MagicOnion](https://github.com/Cysharp/MagicOnion) - Unified Realtime/API framework for .NET platform and Unity.
- [eventflow/EventFlow](https://github.com/eventflow/EventFlow) - Async/await first CQRS+ES and DDD framework for .NET
- [dasiths/SimpleMediator](https://github.com/dasiths/SimpleMediator) - A .NET/C# implementation of the mediator pattern with support for queries, commands and events
- [mayuanyang/Mediator.Net](https://github.com/mayuanyang/Mediator.Net) - A simple mediator for .Net for sending command, publishing event and request response with pipelines supported
- [FoundatioFx/Foundatio](https://github.com/FoundatioFx/Foundatio) - Pluggable foundation blocks for building distributed apps.
- [AsynkronIT/protoactor-dotnet](https://github.com/AsynkronIT/protoactor-dotnet) - Proto Actor - Ultra fast distributed actors for Go, C# and Java/Kotlin
- [Abc-Arbitrage/Zebus](https://github.com/Abc-Arbitrage/Zebus) - A lightweight Peer to Peer Service Bus
- [Shriek-Projects/shriek-fx](https://github.com/Shriek-Projects/shriek-fx) - An easy-to-use rapid development framework developed on the basis of.NET Core 2.0, following the constraints of domain Driven Design (DDD) specifications, combined with the CQRS architecture to provide the infrastructure for event-driven, event backtracking, responsiveness, and more. 
- [daxnet/apworks-core](https://github.com/daxnet/apworks-core) - Apworks framework supporting .NET Core
- [nats-io/nats.net](https://github.com/nats-io/nats.net) - The official C# Client for NATS
- [zeromq/netmq](https://github.com/zeromq/netmq) - A 100% native C# implementation of ZeroMQ for .NET
- [zeromq/clrzmq4](https://github.com/zeromq/clrzmq4) - ZeroMQ C# namespace (.NET and mono, Windows, Linux and MacOSX, x86 and amd64)
- [ThreeDotsLabs/watermill](https://github.com/ThreeDotsLabs/watermill) - Building event-driven applications the easy way in Go.
- [Cysharp/MessagePipe](https://github.com/Cysharp/MessagePipe) - High performance in-memory/distributed messaging pipeline for .NET and Unity.
- [cfrenzel/Eventfully](https://github.com/cfrenzel/Eventfully) - Lightweight Reliable Messaging Framework using Outbox Pattern / EFCore / AzureServiceBus
- [daniellittledev/Enexure.MicroBus](https://github.com/daniellittledev/Enexure.MicroBus) - MicroBus is a simple in process Mediator for .NET
- [simplesoft-pt/Mediator](https://github.com/simplesoft-pt/Mediator) - Small .NET library that helps with the implementation of mediator pattern for commands, events and queries
- [gautema/CQRSlite](https://github.com/gautema/CQRSlite) - A lightweight framework to help creating CQRS and Eventsourcing applications in C#
- [martinothamar/Mediator](https://github.com/martinothamar/Mediator) - A high performance implementation of Mediator pattern in .NET using source generators.
- [AlphaYu/Adnc](https://github.com/AlphaYu/Adnc) - The microservice framework is also suitable for the development of monolithic architecture systems. It supports the classic three-tier and DDD architecture development model, and integrates a series of mainstream and stable microservice supporting technology stacks. A framework with front-end and back-end separation. The front-end is based on Vue and the back-end is built on .Net 5.0.
- [Im5tu/OpenMessage](https://github.com/Im5tu/OpenMessage) - Receive messages from multiple sources using a centralised delivery pipeline
- [SorenZ/Alamut.Kafka](https://github.com/SorenZ/Alamut.Kafka) - An opinionated approach to use Apache Kafka in Dotnet
- [revoframework/Revo](https://github.com/revoframework/Revo) - Event Sourcing, CQRS and DDD framework for C#/.NET Core.
- [MesutAtasoy/Joker.Packages](https://github.com/MesutAtasoy/Joker.Packages)
- [oskardudycz/EventSourcing.NetCore/event-pipelines](https://github.com/oskardudycz/EventSourcing.NetCore/tree/samples/event-pipelines/Sample/EventPipelines)
- [GDATASoftwareAG/motornet](https://github.com/GDATASoftwareAG/motornet) - Motor.NET is a microservice framework based on Microsoft.Extensions.Hosting
- [litenova/LiteBus](https://github.com/litenova/LiteBus) - An easy-to-use and ambitious in-process mediator to implement CQS with minimum reflection usage and streamable query support.
- [NHadi/Dermayon](https://github.com/NHadi/Dermayon) - Dermayon is Library for supporting build large application,distributed application, scalable, microservices, cqrs, event sourcing, including generic ef repository pattern with unit of work, generic mongo repository pattern with unit of work, kafka, etc
- [cloudnative-netcore/netcorekit](https://github.com/cloudnative-netcore/netcorekit) - A crafted toolkit for building cloud-native apps on the .NET platform
- [lucabriguglia/OpenCQRS](https://github.com/lucabriguglia/OpenCQRS) - .NET Standard framework to create simple and clean design. Advanced features for DDD, CQRS and Event Sourcing.
- [Eventuous/eventuous](https://github.com/Eventuous/eventuous) - Minimalistic Event Sourcing library for .NET
- [christophe-mommer/CQELight](https://github.com/christophe-mommer/CQELight)
- [Bullabs/Qitar](https://github.com/Bullabs/Qitar) - Domain Driven Design oriented application framework.
- [yang-xiaodong/Savorboard.CAP.InMemoryMessageQueue](https://github.com/yang-xiaodong/Savorboard.CAP.InMemoryMessageQueue) - In-Memory message queue for CAP
- [osstotalsoft/nbb](https://github.com/osstotalsoft/nbb)
- [liuhll/silky](https://github.com/liuhll/silky) - The Silky framework is designed to help developers quickly build a microservice development framework through simple code and configuration under the .net platform.
- [JasperFx/wolverine](https://github.com/JasperFx/wolverine) - Next Generation .NET Command and Message Bus
- [boyney123/eventcatalog](https://github.com/boyney123/eventcatalog) - Discover, Explore and Document your Event Driven Architectures powered by Markdown.
- [EasyDesk/easydesk-clean-architecture](https://github.com/EasyDesk/easydesk-clean-architecture) - A microservice framework based on the Clean Architecture and the Domain Driven Design.
- [dotnet/aspire](https://github.com/dotnet/aspire) - .NET Aspire is an opinionated, cloud ready stack for building observable, production ready, distributed applications

## 📚 Books
- [Enterprise Integration Patterns](https://amazon.com/o/asin/0321200683/ref=nosim/enterpriseint-20)
- [Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems](https://www.amazon.com/Designing-Data-Intensive-Applications-Reliable-Maintainable/dp/1449373321/)
- [Making Sense of Stream Processing](https://www.goodreads.com/book/show/29598815-making-sense-of-stream-processing)
- [Streaming Systems: The What, Where, When, and How of Large-Scale Data Processing](https://www.amazon.com/Streaming-Systems-Where-Large-Scale-Processing/dp/1491983876)
- [Designing Event-Driven Systems](https://www.confluent.io/designing-event-driven-systems/)
- [Building Event-Driven Microservices: Leveraging Organizational Data at Scale](https://www.amazon.com/Building-Event-Driven-Microservices-Leveraging-Organizational/dp/1492057894)
- [Practical Event-Driven Microservices Architecture: Building Sustainable and Highly Scalable Event-Driven Microservices](https://www.amazon.com/Practical-Event-Driven-Microservices-Architecture-Sustainable/dp/1484274679/)